/*
 * Copyright © 2025 秋辞未寒 (545073804@qq.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.gitee.colordreams.mapstruct.convert.util;

import java.util.*;
import java.util.function.Supplier;

/**
 * 集合工具类
 *
 * @author 秋辞未寒
 */
public class CollectionUtil {

    /**
     * 数组是否为空
     *
     * @param array 数组
     * @return true-为空/false-不为空
     */
    public static <T> boolean isEmpty(T[] array) {
        return array == null || array.length == 0;
    }

    /**
     * 数组是否不为空
     *
     * @param array 数组
     * @return true-不为空/false-为空
     */
    public static <T> boolean isNotEmpty(T[] array){
        return !isEmpty(array);
    }

    /**
     * 迭代器是否为空
     * @param iterable 迭代器
     * @return true-为空/false-不为空
     */
    public static boolean isEmpty(Iterable<?> iterable) {
        return null == iterable || isEmpty(iterable.iterator());
    }

    /**
     * 迭代器是否不为空
     * @param iterable 迭代器
     * @return true-不为空/false-为空
     */
    public static boolean isNotEmpty(Iterable<?> iterable) {
        return !isEmpty(iterable);
    }

    /**
     * 迭代器是否为空
     * @param iterator 迭代器
     * @return true-为空/false-不为空
     */
    public static boolean isEmpty(Iterator<?> iterator) {
        return null == iterator || !iterator.hasNext();
    }

    /**
     * 迭代器是否不为空
     * @param iterator 迭代器
     * @return true-不为空/false-为空
     */
    public static boolean isNotEmpty(Iterator<?> iterator) {
        return !isEmpty(iterator);
    }

    /**
     * 集合是否为空
     * @param collection 集合
     * @return true-为空/false-不为空
     */
    public static boolean isEmpty(Collection<?> collection) {
        return collection == null || collection.isEmpty();
    }

    /**
     * 集合是否不为空
     * @param collection 集合
     * @return true-不为空/false-为空
     */
    public static boolean isNotEmpty(Collection<?> collection) {
        return !isEmpty(collection);
    }

    /**
     * 集合为空时返回默认集合，否则返回原集合
     * @param collection 集合
     * @param defaultCollection 默认集合
     * @param <T> 集合类型
     * @param <E> 集合元素类型
     * @return 集合/默认集合
     */
    public static <T extends Collection<E>, E> T defaultIfEmpty(T collection, T defaultCollection) {
        return isEmpty(collection) ? defaultCollection : collection;
    }

    /**
     * 集合为空时返回默认集合，否则返回原集合
     * @param collection 集合
     * @param defaultCollectionSupplier 默认集合提供者
     * @param <T> 集合类型
     * @param <E> 集合元素类型
     * @return 集合/默认集合
     */
    public static <T extends Collection<E>, E> T defaultIfEmpty(T collection, Supplier<T> defaultCollectionSupplier) {
        return isEmpty(collection) ? defaultCollectionSupplier.get() : collection;
    }

    /**
     * 创建ArrayList
     * @param elements 元素
     * @param <E> 元素类型
     * @return ArrayList
     */
    @SafeVarargs
    public static <E> ArrayList<E> newArrayList(E... elements) {
        return (ArrayList<E>) list(false, elements);
    }

    /**
     * 创建LinkedList
     * @param elements 元素
     * @param <E> 元素类型
     * @return LinkedList
     */
    @SafeVarargs
    public static <E> LinkedList<E> newLinkedList(E... elements) {
        return (LinkedList<E>) list(true, elements);
    }

    /**
     * 创建List
     * @param isLinked 是否创建LinkedList
     * @param elements 元素
     * @param <E> 元素类型
     * @return List
     */
    @SafeVarargs
    public static <E> List<E> list(boolean isLinked, E... elements) {
        if (isEmpty(elements)) {
            return list(isLinked);
        }
        final List<E> arrayList = isLinked ? new LinkedList<>() : new ArrayList<>(elements.length);
        Collections.addAll(arrayList, elements);
        return arrayList;
    }

    /**
     * 创建List
     * @param isLinked 是否创建LinkedList
     * @param <E> 元素类型
     * @return List
     */
    public static <E> List<E> list(boolean isLinked) {
        return isLinked ? new LinkedList<>() : new ArrayList<>();
    }

}
